home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Fixation 1.3 / blit.c next >
Encoding:
Text File  |  1995-10-13  |  4.5 KB  |  150 lines  |  [TEXT/MMCC]
  1. // blit.c
  2.  
  3. #include "blit.h"
  4. #include "error.h"
  5.  
  6.     // safe and mild, assumes both pixmaps same size
  7.     //
  8.     // assumes:
  9.     // bounds start at 0, 0 of pixmaps
  10. void copydouble(PixMapPtr srcpm, PixMapPtr dstpm, Rect *srcRect, Rect *dstRect)
  11. {
  12.     long *src, *dst, dest;
  13.     long srcrb, dstrb, soffset, doffset, loopoffset;
  14.     int offset, rowlongs, loop;
  15.     Rect *srcbounds, *dstbounds, *r;
  16.     int starty, endy, startx, endx, padding;
  17.         
  18.     srcbounds = &srcpm->bounds;
  19.     dstbounds = &dstpm->bounds;
  20.  
  21.         // find vertical indices
  22.     r = srcRect;        // should be same, so don't matter none
  23.     starty = r->top; endy = r->bottom;
  24.     if (starty < 0) starty = 0;
  25.     if (endy >= srcbounds->bottom) endy = srcbounds->bottom - 1;
  26.     if (endy <= 0) return;
  27.     if (starty >= srcbounds->bottom) return;
  28.     
  29.         // find horizontal indices
  30.         // make sure they align to 32-bits (assuming 8-bit depth)
  31.     startx = r->left;
  32.     if (startx < 0) startx = 0;
  33.     if (startx >= srcbounds->right) return;
  34.     startx = (startx >> 2) << 2;    // clear 2 least-significant bits
  35.  
  36.     endx = r->right;
  37.     if (endx <= 0) return;
  38.     if (endx > srcbounds->right) endx = srcbounds->right;
  39.     padding = endx & 3;
  40.     if (padding)
  41.         endx += 4 - padding;    // endx is now aligned
  42.     rowlongs = (endx - startx) >> 2;
  43.          // rect should now be clipped
  44.  
  45.     src = (long *) srcpm->baseAddr;
  46.     dst = (long *) dstpm->baseAddr;
  47.     srcrb = srcpm->rowBytes & 0x3fff;
  48.     dstrb = dstpm->rowBytes & 0x3fff;
  49.     verify(srcrb == dstrb);
  50.  
  51.         // set up offsets
  52.     soffset = startx;
  53.     soffset += starty * srcrb;
  54.     src = (long *) ((long) src + soffset);
  55.     
  56.     doffset = startx;
  57.     doffset += starty * dstrb;
  58.     dst = (long *) ((long) dst + doffset);
  59.         
  60.         // prepare for loop
  61.     loop = endy - starty;
  62.     loopoffset = srcrb - (rowlongs << 2);
  63.     
  64.         // copy the pix
  65.     while (loop-- > 0) {
  66.         switch (rowlongs) {
  67.             case 24:        *dst++ = *src++;
  68.             case 23:        *dst++ = *src++;
  69.             case 22:        *dst++ = *src++;
  70.             case 21:        *dst++ = *src++;
  71.             case 20:        *dst++ = *src++;
  72.             case 19:        *dst++ = *src++;
  73.             case 18:        *dst++ = *src++;
  74.             case 17:        *dst++ = *src++;
  75.             case 16:        *dst++ = *src++;
  76.             case 15:        *dst++ = *src++;
  77.             case 14:        *dst++ = *src++;
  78.             case 13:        *dst++ = *src++;
  79.             case 12:        *dst++ = *src++;
  80.             case 11:        *dst++ = *src++;
  81.             case 10:        *dst++ = *src++;
  82.             case 9:         *dst++ = *src++;
  83.             case 8:         *dst++ = *src++;
  84.             case 7:         *dst++ = *src++;
  85.             case 6:         *dst++ = *src++;
  86.             case 5:         *dst++ = *src++;
  87.             case 4:         *dst++ = *src++;
  88.             case 3:         *dst++ = *src++;
  89.             case 2:         *dst++ = *src++;
  90.             case 1:         *dst++ = *src++;
  91.             case 0:            break;
  92. //            default: DebugPrint(srcRect->right - srcRect->left); verify(false);
  93.         }
  94.         dst = (long *) (((long) dst) + loopoffset);
  95.         src = (long *) (((long) src) + loopoffset);
  96.     }
  97. }
  98.  
  99.  
  100.  
  101.  
  102.  
  103. static void copyslick(PixMapPtr srcpm, PixMapPtr dstpm, Rect *srcRect, Rect *dstRect)
  104. {
  105.     long *src, *dst, dest;
  106.     long srcrb, dstrb;
  107.     int offset;
  108.     Rect *srcbounds, *dstbounds;
  109.         
  110.     srcbounds = &srcpm->bounds;
  111.     dstbounds = &dstpm->bounds;
  112.     
  113.         // check for rect situations that should do nuttin'
  114.     if ((srcRect->right < 0) || (srcRect->left >= srcbounds->right) ||
  115.             (srcRect->bottom < 0) || (srcRect->top >= srcbounds->bottom) ||
  116.             (dstRect->right < 0) || (dstRect->left >= dstbounds->right) ||
  117.             (dstRect->bottom < 0) || (dstRect->top >= dstbounds->bottom))
  118.         return;
  119.     
  120.         // perform simple clipping
  121.     if (srcRect->left < 0) {
  122.         offset = -srcRect->left;
  123.         srcRect->left += offset; dstRect->left += offset;
  124.     }
  125.     if (srcRect->top < 0) {
  126.         offset = -srcRect->top;
  127.         srcRect->top += offset; dstRect->top += offset;
  128.     }
  129.     offset = srcRect->right - srcbounds->right;
  130.     if (offset > 0)
  131.         srcRect->right -= offset; dstRect->right -= offset;
  132.     offset = srcRect->bottom - srcbounds->bottom;
  133.     if (offset > 0)
  134.         srcRect->bottom -= offset; dstRect->bottom -= offset;
  135.         // rects should now be clipped
  136.  
  137.     src = (long *) srcpm->baseAddr;
  138.     dest = (long) dstpm->baseAddr;
  139.     srcrb = srcpm->rowBytes & 0x3fff;
  140.     dstrb = dstpm->rowBytes & 0x3fff;
  141.  
  142. //   dest += r->left;
  143.  //   dest += r->top * dstrb;
  144.     dst = (long *) dest;
  145.     
  146.         // copy the pix
  147.     *dst = *src;
  148.     dst = (long *) ((long) dst + dstrb);
  149.     src = (long *) ((long) src + srcrb);
  150. }